package com.eric.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.dev33.satoken.util.SaResult;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.eric.domain.bso.UserRoleBso;
import com.eric.domain.dto.UserRoleDto;
import com.eric.domain.po.SysRole;
import com.eric.domain.po.UserRole;
import com.eric.mapper.UserRoleMapper;
import com.eric.service.ISysRoleService;
import com.eric.service.ISysUserService;
import com.eric.service.IUserRoleService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import static com.eric.utils.Constant.PAGE_CURRENT;
import static com.eric.utils.Constant.PAGE_SIZE;

/**
 * <p>
 * 用户_角色表 服务实现类
 * </p>
 *
 * @author 新哥
 * @since 2024-03-12
 */
@Service
@RequiredArgsConstructor
@Transactional
public class UserRoleServiceImpl extends MPJBaseServiceImpl<UserRoleMapper, UserRole> implements IUserRoleService {
    private final ISysRoleService roleService;
//    private final ISysUserService userService;
    @Override
    @Transactional
//    添加新的UserRole对象（1~N个）
    public SaResult saveUserRole(Map<String, List<Integer>> paramMaps) {
//        获取到前端传进的user_id,roleIdList
        List<Integer> userIds_Vue = paramMaps.get("userIds");
        List<Integer> roleIds_Vue = paramMaps.get("roleIds");
//        获取数据库中Role的全部Role
        List<SysRole> roleList_db = roleService.list();
//        把获取到的Role的RoleId放到一个列表roleIdList中
        List<Integer>roleIdList_db=new ArrayList<>();
        for (SysRole sysRole : roleList_db) {
            roleIdList_db.add(sysRole.getId());
        }
//        判断传进来的数据roleIds是否都包含在数据库中，是通过，否就return错误
        boolean b = new HashSet<>(roleIdList_db).containsAll(roleIds_Vue);
        if (!b){
            return SaResult.error("输入的角色数据库中不存在，请检查后再次输入！");
        }
//      只使用0索引，因为都只是一个userId
        Integer userIdVue = userIds_Vue.get(0);
//      通过前端传来的user_id查询数据库，获取UserRole对象列表--mybatis-plus的list()方法
        List<UserRole> userRoleInDb = query().eq("user_id", userIdVue).list();
//      如果数据库中一条数据都没有 ，就添加进去
        if (userRoleInDb.isEmpty()){
            List<UserRole>userRoleList=new ArrayList<>();
            for (Integer roleId : roleIds_Vue) {
                UserRole userRole=new UserRole();
                userRole.setUserId(userIdVue);
                userRole.setRoleId(roleId);
                userRoleList.add(userRole);
            }
            saveBatch(userRoleList);
            return SaResult.ok("新UserRole数据已经被添加！");
        }
//        把数据库中查询到的UseRole对象转换成UserRoleBso类型列表（只有user_id,role_id两个属性）
        List<UserRoleBso> userRoleBsosInDb = BeanUtil.copyToList(userRoleInDb, UserRoleBso.class);
//        把前端传进来的数据，生成userRoleBso类型
        List<UserRoleBso>userRoleBsoListVue=new ArrayList<>();
        for (Integer roleId : roleIds_Vue) {
            UserRoleBso userRoleBso=new UserRoleBso();
            userRoleBso.setUserId(userIdVue);
            userRoleBso.setRoleId(roleId);
            userRoleBsoListVue.add(userRoleBso);
        }
        userRoleBsoListVue.removeAll(userRoleBsosInDb);
        List<UserRole> userRoleList = BeanUtil.copyToList(userRoleBsoListVue, UserRole.class);
        if (userRoleList.isEmpty()){
            return SaResult.error("UserRole数据已存在，请检查后再次输入!");
        }

////            通过登录id和userService，获取到用户的realName
//        String realName = userService.getById(Integer.parseInt(StpUtil.getLoginId().toString())).getRealName();
//
//        for (UserRole userRole : userRoleList) {
//            userRole.setCreateBy(realName);
//            userRole.setLastUpdateBy(realName);
//        }
        saveBatch(userRoleList);
        return SaResult.ok("新的UserRole数据已经被添加！");
    }

    @Override
//    获取登录用户的角色列表
//    如果在user_role表中没有注册user_role关系，默认返回一个sys:visitor角色
    public List<String> getLoginUserRoleList(Object loginId, String s) {
        int login_Id = Integer.parseInt(loginId.toString());
//        根据userId查询UserRole表数据，返回UserRole对象列表
        List<UserRole> userRoleList = query().eq("user_id", login_Id).list();
//        把查到的对象列表转换成UserRoleBso对象列表
        List<UserRoleBso> userRoleBsoList = BeanUtil.copyToList(userRoleList, UserRoleBso.class);
//        获取到RoleId列表
        List<Integer>userRole_RoleIds=new ArrayList<>();
        for (UserRoleBso userRoleBso : userRoleBsoList) {
            userRole_RoleIds.add(userRoleBso.getRoleId());
        }
//    todo    如果userRole_roleIds集合是空，就返回一个角色visitor回到SaToken
        if (userRole_RoleIds.isEmpty()){
            List<String>roleNameList=new ArrayList<>();
            roleNameList.add("sys:visitor");
            return roleNameList;
        }
//        如果不为空，执行下面代码
//        根据获取到的RoleId列表，查询SysRole表的数据，用MybatisPlus的listByIds方法
        List<SysRole> roleList = roleService.listByIds(userRole_RoleIds);
//        把获取到的SysRole对象中获取到的roleName放到一个String类型列表中
        List<String>roleNameList=new ArrayList<>();
        for (SysRole sysRole : roleList) {
            roleNameList.add(sysRole.getRoleName());
        }
//       把这个列表返回
        return roleNameList;
    }

    @Override
    @Transactional
    /*
     *     作用：删除指定User对应的Role角色
     *     参数是一个Map，2个键值对
     *     第一个键值对：userIds:[userId]
     *     第二个键值对: roleIds:[roleId]
     *     现在把userIds的数组元素写死是一个，roleId数组可以1~N个
     *
     *     user-role表，就用一个增加，一个删除就够了，毕竟这个表很少用
     * */
    public SaResult deleteUserRolesService(Map<String, List<Integer>> ids) {
//        从Map中获取userId和roleId的List<Integer>
        List<Integer> userIds = ids.get("userIds");
        List<Integer> roleIds = ids.get("roleIds");

//        分别判断userId和roleIds是否为空
        if (userIds.isEmpty()){
            return SaResult.error("userId缺失，请重新输入！");
        }
        if (roleIds.isEmpty()){
            return SaResult.error("roleId缺失，请重新输入！");
        }
//        降低程序的复杂度，前端仅仅传输一个userId
        Integer userId = userIds.get(0);

        List<UserRoleDto>userRoleDtoList=new ArrayList<>();
        for (Integer roleId : roleIds) {
            UserRoleDto userRoleDto=new UserRoleDto();
            userRoleDto.setUserId(userId);
            userRoleDto.setRoleId(roleId);
            userRoleDtoList.add(userRoleDto);
        }
        List<UserRole> userRoleList = BeanUtil.copyToList(userRoleDtoList, UserRole.class);
        for (UserRole userRole : userRoleList) {
            MPJLambdaWrapper<UserRole>wrapper=new MPJLambdaWrapper<UserRole>()
//                    wrapper：userId等于传进来的userId，roleId等于传进来的roleId作为匹配条件
                    .eq(UserRole::getUserId,userId).eq(UserRole::getRoleId,userRole.getRoleId());
            remove(wrapper);
        }
        return SaResult.ok();
    }

    @Override
    public SaResult getAllService(Integer current, Integer pageSize) {
        if (current==null){
            current=PAGE_CURRENT;
        }
        if (pageSize==null){
            pageSize=PAGE_SIZE;
        }
        Page<UserRole>page=new Page<>(current,pageSize);
        List<UserRole> userRoleList = query().orderByDesc("update_time").page(page).getRecords();
        List<UserRoleDto> userRoleDtoList = BeanUtil.copyToList(userRoleList, UserRoleDto.class);
        return SaResult.data(userRoleDtoList);
    }

    @Override
    public SaResult getByUserIdService(Integer userId, Integer current, Integer pageSize) {
        if (userId==null){
            return SaResult.error("userId不能为空！");
        }
        if (current==null){
            current=1;
        }
        if (pageSize==null){
            pageSize=10;
        }
        Page<UserRole>page=new Page<>(current,pageSize);
        List<UserRole> userRoleList = query().eq("user_id", userId).orderByDesc("update_time")
                .page(page).getRecords();
        List<UserRoleDto> userRoleDtoList = BeanUtil.copyToList(userRoleList, UserRoleDto.class);
        return SaResult.data(userRoleDtoList);
    }

    @Override
    public SaResult getOneByIdService(Integer id) {
        if (id==null){
            return SaResult.error("id不能为空");
        }
        UserRole userRole = query().eq("id", id).one();
        UserRoleDto userRoleDto = BeanUtil.copyProperties(userRole, UserRoleDto.class);
        return SaResult.data(userRoleDto);
    }

    @Override
    public SaResult updateUserRoles(Map<String, List<Integer>> paramMaps) {

//        获取到前端传进的user_id,roleIdList
        List<Integer> userIds_Vue = paramMaps.get("userIds");
        List<Integer> roleIds_Vue = paramMaps.get("roleIds");

//        获取数据库中Role的全部Role
        List<SysRole> roleList_db = roleService.list();
//        把获取到的Role的RoleId放到一个列表roleIdList中
        List<Integer>roleIdList_db=new ArrayList<>();
        for (SysRole sysRole : roleList_db) {
            roleIdList_db.add(sysRole.getId());
        }
//        判断传进来的数据roleIds是否都包含在数据库中，是通过，否就return错误
        boolean b = new HashSet<>(roleIdList_db).containsAll(roleIds_Vue);
        if (!b){
            return SaResult.error("输入的角色数据库中不存在，请检查后再次输入！");
        }
//      只使用0索引，因为都只是一个userId
        Integer userIdVue = userIds_Vue.get(0);
//      通过前端传来的user_id查询数据库，获取UserRole对象列表--mybatis-plus的list()方法
        List<UserRole> userRoleInDb = query().eq("user_id", userIdVue).list();

        List<Integer>ids=new ArrayList<>();
        for (UserRole userRole : userRoleInDb) {
            ids.add(userRole.getId());
        }

//        第一步：先删除原来的UserRole
        removeBatchByIds(ids);
        //      把新的数据插入进去
            List<UserRole>userRoleList=new ArrayList<>();
            for (Integer roleId : roleIds_Vue) {
                UserRole userRole=new UserRole();
                userRole.setUserId(userIdVue);
                userRole.setRoleId(roleId);
                userRoleList.add(userRole);
            }
        boolean saveBatch = saveBatch(userRoleList);

        return saveBatch ? SaResult.ok("修改成功") : SaResult.error("修改失败");


    }
}
